import ficha.*; //Importo la clase ficha
import java.util.Random; //Para numeros aleatorios
import java.io.InputStreamReader; //Entrada y salida por teclado
import java.io.BufferedReader;
import java.io.IOException;

public class ej39domino {
	public static int[] sepuede (int n_o, Ficha ficha[], int ordenador[],String tablero){
		int i,j,k;
		int forma=0; /*Dice de que forma se puede tirar la ficha, de la siguiente forma
		 0. POR DEFECTO
		 1. se tira a la izquierda del tablero dando la vuelta
		 2. se tira a la izquierda del tablero sin dar la vuelta
		 3. se tira a la derecha del tablero sin dar la vuelta
		 4. se tira a la derecha del tablero dando la vuelta
		*/
		int id=30,pos1=0,pos2=0;
		int devuelve[] = new int [4];
		//CALCULA QUE VALORES SE PUEDEN TIRAR
		if (tablero.length()!=0){ //Se ejecutara si hay fichas colocadas y si no se ha tirado
			pos1 = Integer.parseInt(""+tablero.charAt(0));	//La posicion1 que se puede tirar es la que ocupa el extremo izq del tablero, se pasa el valor numerico del caracter en dicha posicion
			pos2 = Integer.parseInt(""+tablero.charAt(tablero.length() -1)); //la que ocupa el final del tablero, se hace lo mismo que antes, pero con la ultimia posicion.
			/* No confundir la representacion de las fichas en el tablero,
			 * que se hace por el el valor de cada trozo, con la representacion
			 * en memoria, que se hace mediante un identificador a cada ficha completa.*/
		}
		//FIN DE CALCULAR QUE SE PUEDE TIRAR
		//CALCULO SI SE PUEDE TIRAR, calcula si se tiene alguno de los valores que se pueden tirar y graba de que forma
		for(i=0;i<n_o;i++){ //Solo mira desde la ficha 0 hasta la ultima que tiene
			//guardo los valores de la ficha en j y k para acortar luego la longitud de las condiciones
			j=ficha[ordenador[i]].cara1;
			k=ficha[ordenador[i]].cara2;
			//Dependiendo que valor de la ficha coincida con uno que se pueda tirar, se tirara de una forma u otra (ver codificacion al inicio del metodo)
			if(pos1==j){
				forma = 1;
				id=i; //Se sobreescribe el valor de la ficha que se puede tirar en ID
			}
			else if(pos1==k){
				forma = 2;
				id=i; //Se sobreescribe el valor de la ficha que se puede tirar en ID
			}
			else if(pos2==j){
				forma =3;
				id=i; //Se sobreescribe el valor de la ficha que se puede tirar en ID
			}
			else if (pos2==k){
				forma=4;
				id=i; //Se sobreescribe el valor de la ficha que se puede tirar en ID
			}
		}
		/* Asi, dependiendo del valor de "forma", se sabra si es posible tirar una ficha
		 * (forma!=0), como hay que tirarla(forma(1,2,3,4), y que ficha es la que se puede
		 * tirar cuyo identificador queda almacenado en ID.
	FIN DE SI SE PUEDE TIRAR*/
		devuelve[0]=forma;//Devuelve tiene el valor de forma en el primer campo y de ID en el segundo.
		devuelve[1]=id;
		devuelve[2]=pos1;
		devuelve[3]=pos2;
		return devuelve;
	}

	public static void tirarficha(auxiliar aux){
		//METODO RECURSIVO, se le pasan valores con un objeto, son por REFERENCIA
		String cara1,cara2; //Strings auxiliares
		boolean hecho=false;
		int id; //identifcador de ficha
		int devuelve[] = new int [2];
		Random random = new Random(); //Para numeros aleatorios
		if(aux.n_o==7&&aux.forma==0){ //CASO BASE 1: Si no puede tirar ni robar.
			System.out.println("PASA TURNO");
		}
		else if (aux.forma!=0){//CASO BASE 2: Que puedas tirar
			if (aux.forma ==1 ){ //Se tira a la izq dando la vuelta
				//Se pasa antes la cara a un String para evitar qeu sume los valores de las caras y luego concatene
				cara1 = aux.ficha[aux.ordenador[aux.tirar]].cara1+"";
				cara2 = aux.ficha[aux.ordenador[aux.tirar]].cara2+"";
				aux.tablero = cara2 + cara1 + aux.tablero;
			}
			else if (aux.forma==2){ //Se tira a la izquierda sin dar la vuelta
				cara1 = aux.ficha[aux.ordenador[aux.tirar]].cara1+"";
				cara2 = aux.ficha[aux.ordenador[aux.tirar]].cara2+"";
				aux.tablero = cara1 + cara2 + aux.tablero;
			}
			else if (aux.forma==3){ //Se tira a la derecha sin dar la vuelta
				cara1 = aux.ficha[aux.ordenador[aux.tirar]].cara1+"";
				cara2 = aux.ficha[aux.ordenador[aux.tirar]].cara2+"";
				aux.tablero = aux.tablero + cara1 + cara2;
				}
			else{ //Se tira a la derecha dando la vuelta
				cara1 = aux.ficha[aux.ordenador[aux.tirar]].cara1+"";
				cara2 = aux.ficha[aux.ordenador[aux.tirar]].cara2+"";
				aux.tablero = aux.tablero + cara2 + cara1;
				}
			aux.ordenador[aux.tirar] = aux.ordenador[aux.n_o-1]; //Machaca sobre la ficha tirada la ultima ficha que tiene el ordenador
			aux.n_o--; //Decrementa el numero de fichas que tienes
		}
		else { //En este caso, no puedes tirar y robas, tras robar, vuelves a intentar tirar llamando recursivamente
			//ROBA UNA FICHA
			/* Genera fichas aleatorias hasta que de con una sin utilizar,
			 * en cuanto lo haga, la reparte y pone como utilizada y cuenta que el jugador
			 * tiene una ficha mas*/
			do{
				hecho = false; //marca que tiene que repartir
				id = random.nextInt(28); // Genera un numero aleatorio entre las fichas
				if(aux.ficha[id].usado == false){
					aux.ordenador[aux.n_o] = id;
					aux.ficha[id].usado=true;
					hecho = true;//marca que ya ha repartido
				}
			}
			while (hecho==false);//se repite mientras no se haya repartido
			aux.n_o++; //El jugador posee una ficha mas.
			aux.totales++;//Se ha repartido una ficha
			//Antes de volver a intentar sacar ficha, miro a ver que y como se puede tirar con la funcion "sepuede
			//saco los nuevos valores de "forma" y "TIRAR"
			devuelve = sepuede(aux.n_o, aux.ficha, aux.ordenador,aux.tablero);
			aux.forma = devuelve[0]; //Se recoge la forma posible resultado del metodo sepuede
			aux.tirar = devuelve[1]; //Lo mismo pero con la ficha que se puede colocar
			System.out.println("EL ORDENADOR ROBA FICHA"); //Para poder "ver" cuando roba el ordenador
			//DESPUES DE ROBAR MUESTRA LAS FICHAS QUE TIENE AHORA (descomentar para ver las fichas del ordenador)
			//lista(aux.ficha,aux.ordenador,aux.n_o);			
			tirarficha(aux);//una vez que se ha repartido la ficha, llama recursivamente a la funcion sacarficha para ver si ahora puede tirar
		}
	}
	
	public static void ver_tablero(String tablero){
		/*Enseña el tablero con fichas "parecidas" a las del domino
		 * es totalmente prescindible, se podria imprimir simplemente el String tablero
		 * aunque asi graficamente queda "mejor" */
		int i; //iterador		
		System.out.print("\t\tTablero actual\n\t");
		for(i=0;i<tablero.length()-1;i=i+2){
			System.out.print("["+tablero.charAt(i)+"].");
			System.out.print("["+tablero.charAt(i+1)+"]");
		}
		System.out.println("\n");
	}
	
	public static void lista (Ficha ficha[],int muestra[],int n){
		//Imprime del jugador que se le envie tantas fichas como tenga
		int i; //iterador
		System.out.println("\n\tFICHAS");
		for(i=0;i<n;i++){
			System.out.print(muestra[i]+".- ");
			ficha[muestra[i]].Mostrar();
			System.out.print("\t");
			if(i%2!=0)
				System.out.println();
		}
		System.out.println();
	}
	
	public static void main(String[] args) throws IOException{
		//Variables, vectores, objetos
		boolean hecho; //Cuenta si ha repartido una ficha o no, si se tiene el 6 doble
		boolean tirado=false;//marca que se ha tirado la ficha
		boolean termina =false; //Determina el final de la partida
		boolean rotar =false; //Determina si se tiene que rotar la ficha del jugador
		boolean pasar =false; //Permite pasar turno al jugador
		char car='N'; //Dice el lado donde se va a tirar la ficha para el jugador
		int i,j,k; //iteradores y como comodin
		int id=0; //identificador de ficha
		int tirar=0;//ficha qeu se va a tirar
		int n_j=0, n_o=0,totales=0; //Numero de fichas que posee el jugador y el ordenador, fichas repartidas
		int turno=0; //contador del turno de la partida. los turnos pares son del jugador y los impares del ordenador
		int pos1=0,pos2=0; //Valores posibles que se pueden tirar
		int doble; //almacena identidades de fichas dobles
		int forma;/*Dice de que forma se puede tirar la ficha, de la siguiente forma
		 0. POR DEFECTO
		 1. se tira a la izquierda del tablero dando la vuelta
		 2. se tira a la izquierda del tablero sin dar la vuelta
		 3. se tira a la derecha del tablero sin dar la vuelta
		 4. se tira a la derecha del tablero dando la vuelta*/
		int devuelve[] = new int [4]; //Vector para recoger varios resultados de un metodo.
		int jugador[] = new int [7]; //Identificadores de las fichas del jugador
		int ordenador[] = new int [7];//del ordenador
		Random random = new Random(); //Para numeros aleatorios
		InputStreamReader teclado = new InputStreamReader (System.in);//Entrada por teclado
		BufferedReader buffer = new BufferedReader (teclado);	//buffer de entrada
		Ficha ficha[] = new Ficha[28]; //Vector que contiene todas las fichas del juego
		auxiliar aux = new auxiliar(); //Objeto para pasar por referencia algunos valores como el tablero
		String entrada =""; //para pasar entradas por teclado
		String cara1="",cara2=""; //Para concatenar las nuevas caras al tablero
		String tablero = "";
		/* Represento el tablero como un String, donde se tendran en cuenta
		 * los valores de la primera y ultima posicion para saber que fichas
		 * se podran colocar a continuacion.
		 * De esta forma, cuando añadas una ficha a la izquierda, solo tienes
		 * que en el mismo string concatenar la ficha + el string, y quedara a
		 * la izquierda la nueva ficha. Para añadir a la derecha, concatenas al
		 * final del string.*/
		//Generacion de las 28 Fichas
		/* En este bucle los iteradores corresponden con:
		 * i = identificador de la ficha que se esta generando
		 * j = valor de la cara 1
		 * k = valor de la cara 2*/
		i=0;//Inicio para que la primera ficha (6-6) tenga el identificador 0
		for(j=6;j>=0;j--) //disminuye el valor de la cara 1
			for(k=j;k>=0;k--,i++){ //disminuye el valor de la cara2 y aumenta el identificador de ficha
				ficha[i] = new Ficha();
				ficha[i].cara1 = j;
				ficha[i].cara2 = k;
			}
		/* Las 28 Fichas generadas aparecen representadas junto con su identificador
		 * al final del codigo como comentario, para poder revisar facilmente que identificadores
		 * corresponden a fichas importantes como por ejemplo el 6-6, los dobles, etc...
		 * a la hora de ver quien sale o depurar el codigo */
		//INICIO DE REPARTIR FICHAS
		//Primero reparte las fichas al Jugador
		for(i=0;i<7;i++){
			/* Genera fichas aleatorias hasta que de con una sin utilizar,
			 * en cuanto lo haga, la reparte y pone como utilizada y cuenta que el jugador
			 * tiene una ficha mas*/
			do{
				hecho = false; //marca que tiene que repartir
				id = random.nextInt(28); // Genera un numero aleatorio entre las fichas
				if(ficha[id].usado == false){
					jugador[n_j] = id;
					ficha[id].usado=true;
					hecho = true;//marca que ya ha repartido
				}
			}
			while (hecho==false);//se repite mientras no se haya repartido
			n_j++; //El jugador posee una ficha mas.
			totales++;//Se ha repartido una ficha
		}
		//Reparte las fichas al Ordenador
		for(i=0;i<7;i++){
			/* Genera fichas aleatorias hasta que de con una sin utilizar,
			 * en cuanto lo haga, la reparte y pone como utilizada y cuenta que el jugador
			 * tiene una ficha mas*/
			do{
				hecho = false; //marca que tiene que repartir
				id = random.nextInt(28); // Genera un numero aleatorio entre las fichas
				if(ficha[id].usado == false){
					ordenador[n_o] = id;
					ficha[id].usado=true;
					hecho = true;//marca que ya ha repartido
				}
			}
			while (hecho==false);//se repite mientras no se haya repartido
			n_o++; //El jugador posee una ficha mas.
			totales++;//Se ha repartido una ficha
		}
		//FIN DEL REPARTIR FICHAS
		//INICIO DE VER QUIEN EMPIEZA
		//los turnos pares son del jugador y los impares del ordenador
		//BUSCO EL 6 DOBLE, corresponde con la ficha 0.
		hecho = false; //comprobara si ha salido el 6 doble, por defecto no.
		for(i=0;i<7;i++){
			if(jugador[i]==0){ //Si el jugador tiene el 6 doble empieza
				turno = 0;
				hecho = true;
			}
			else if(ordenador[i]==0){
				turno = 1;
				hecho = true;
			}		
		}
		//Busco quien tiene el mayor doble, para ello busco los identificadores
		//De las fichas dobles distintas de 6-6, que en orden mayor-menor son:
		// 7, 13, 18, 22, 25 y 27   (Salen en el ultimo comentario con los identificadores de cada ficha)
		//dichos valores los guardare en los iteradores j (para el jugador)
		//y k para el ordenador, a fin de poder luego ver cual es menor
		//el MAYOR DOBLE tendra el identificador menor, por lo que el que posea el identificador menor empieza
		if(hecho==false){ //solo buscare el mayor doble si no se ha encontrado el 6 doble.
			j=30;//inicio a valores altos
			k=30; 
			for(i=0;i<7;i++){
				//	busca el mayor doble del jugador
				if(((jugador[i]==7)||(jugador[i]==13)||(jugador[i]==18)||(jugador[i]==22)||(jugador[i]==25)||(jugador[i]==27))&&jugador[i]<j )
					j=jugador[i];
					/* Si es alguno de los numeros dobles y ADEMAS es menor que el valor
					 * de j (es decir, no se habia encontrado ninguno antes, o
					 * se habia encontrado uno que tiene menos preferencia) el valor
					 * de j se escribe con el menor valor del identificador doble posible.
					 */
				//Ahora con el ordenador
				if(((ordenador[i]==7)||(ordenador[i]==13)||(ordenador[i]==18)||(ordenador[i]==22)||(ordenador[i]==25)||(ordenador[i]==27))&&ordenador[i]<j )
					k=ordenador[i];
			}
			/* Una vez buscados los mayores dobles, si alguno de ellos es distinto
			 * de 30 (es que se encontro un doble) empieza aquel que sea un valor
			 * menor, que querra decir que tiene el mayor doble*/
			if(j!=30||k!=30){ //Si se ha encontrado algun doble evalua cual es el mayor
				if (j<k)	//Si lo tiene el jugador empieza el. 
					turno = 0;
				else 		//Sino, empieza el ordenador.
					turno =1;
				hecho=true; //en cualquiera de los 2 casos, determino quien empieza
							//por lo que hecho se pone a verdadero, para que no siga
							//determinando quien empieza.
			}
		}
		//FINAL DEL MAYOR DOBLE
		//MAYOR DE LAS FICHAS, solo se realiza si no se encontro anteriormente quien empezaba (hecho==false)
		if(hecho=false){
			/* Ahora  busca la mayor de las fichas, la mayor distinta de |6·6| es la |6·5| que suma 11,
			 * por lo que ira buscando aquella ficha cuyo valor suma de las dos caras sea mayor, y lo guarda
			 * para el jugador en la variable J, y para el ordenador en la K, luego comparara dichos valores
			 * y aquel que sea mayor empezara a jugar*/
			j=0;
			k=0;
			for(i=0;i<7;i++){
				if(ficha[jugador[i]].cara1+ficha[jugador[i]].cara2>j)
					j=ficha[jugador[i]].cara1+ficha[jugador[i]].cara2;
				if(ficha[ordenador[i]].cara1+ficha[ordenador[i]].cara2<k)
					k=ficha[ordenador[i]].cara1+ficha[ordenador[i]].cara2;
			}
			//Una vez hallada el la ficha mayor comparo entre
			//jugador y ordenador (j y k) y el mayor, empieza.
			if(j>k)
				turno = 0;
			else
				turno=1;
		}
		//FINAL DE LA MAYOR DE LAS FICHAS
		//FINAL DE VER QUIEN EMPIEZA.
		/*	TURNOS
		 * para hacer los turnos hago un do while, donde ira incrementando el turno al final
		 * dentro de cada iteracion, comprueba si el valor del turno es par o impar, los turnos
		 * pares son aquellos en los que mediante un IF tirara el jugador, y los impares el ordenador*/
		do{
			//Muestra el tablero que hay en ese momento
			ver_tablero(tablero);
			//Turno del ordenador (el turno es impar)
			if(turno%2==1){
				System.out.println("Turno "+turno+": ORDENADOR");
				//Inicio variables (identificador de ficha y si se ha tirado este turno) a valores por defecto
				id=0;
				tirado=false;
				//IMPRIME FICHAS DEL ORDENADOR, DESCOMENTAR PARA MOSTRARLAS, se puede jugar a "mano descubierta"
				//lista(ficha,ordenador,n_o);
				//EN CASO QUE SEA EL PRIMER TURNO se realiza una comprobacion y tira la ficha que "hizo que empezara"
				if(turno==1&&tablero.equals("")){ /*Si es el primer turno y el tablero esta vacio
													querra decir que empezaba el ordenador.
				 	Como al determinar quien empezaba no se guardo que ficha provocaba el empezar, hay
				 	que determinarla de nuevo, el algoritmo se podria mejorar para no tener que hacer
				 	esta parte del programa y dejarlo con muchas menos lineas de codigo, no se mejora
				 	por falta de tiempo*/
					//MAYOR DOBLE
					doble=30;
					for(i=0;i<7;i++){ /* Busca la mayor doble, si tiene las dos caras iguales, comparara con
										la variable "doble" que tiene guardado por defecto (30) y si el identificador
										es menor, es que la ficha doble es de mayor tamaño (pongo 30 puesto que no hay ficha con ese id tan alto)
					 					*/
						if(ficha[ordenador[i]].cara1 == ficha[ordenador[i]].cara2){ 
							if(ordenador[i]<doble){
								doble = ordenador[i];
								j=i;//Guardo el valor de la ficha del vector ordenador que es valida
							}
						}
					}
					//Una vez encontrada la mayor doble, si se ha encontrado doble!=30, entonces la tira
					if(doble!=30){
						i=j;//Recupero el valor de la posicion del vector ordenador donde esta la ficha que se tira
						tablero = ficha[doble].cara1 + ""+ficha[doble].cara2; //añade al tablero la ficha, los "" es porque sino, no convierte los int a String para concatenarlos
						ordenador[i] = ordenador[n_o-1]; //Machaca sobre la ficha tirada la ultima ficha que tiene el ordenador
						n_o--; //Decrementa el numero de fichas que tienes
						tirado=true; //marca como que ya ha tirado
					}
					//FIN MAYOR DOBLE
					//Si todavia no se ha tirado, el ordenador tira la mayor ficha posible
					if(tirado==false){
						j=0; //guarda el identificador de la ficha mayor en esta variable
						k=0;//donde va guardando el valor suma de las caras para su posterior comparacion
						for(i=0;i<7;i++){
							if(ficha[ordenador[i]].cara1+ficha[ordenador[i]].cara2>k){
								k= ficha[ordenador[i]].cara1+ficha[ordenador[i]].cara2;
								j=i;//Guarda el identificador de la ficha mayor en la variable J
							}
						}
						tablero = ficha[ordenador[j]].cara1 + ""+ficha[ordenador[j]].cara2; //añade al tablero la ficha
						ordenador[j] = ordenador[n_o-1]; //Machaca sobre la ficha tirada la ultima ficha que tiene el ordenador
						n_o--; //Decrementa el numero de fichas que tienes
						tirado=true; //marca como que ya ha tirado				
					}
				}
				//FIN DEL CASO PRIMER TURNO
				//En caso de que no sea el primer turno, Inicia la tirada con funcion recursiva
				if(tirado==false&&n_o>0){
					/* La funcion "sepuede" nos dice en funcion del tablero y las fichas que tienes
					 * que valores puedes tirar (aunque aqui no se recojan), la ficha que posees que
					 * podrias tirar (si tienes alguna) y la forma de tirarla (0 para no se puede tirar)
					 * La codificacion de la forma viene recogida dentro del metodo "tirarficha"*/
					devuelve = sepuede(n_o, ficha, ordenador,tablero);
					aux.forma = devuelve[0]; //Se recoge la forma posible resultado del metodo sepuede
					aux.tirar = devuelve[1]; //Lo mismo pero con la ficha que se puede colocar
					aux.n_o = n_o;			//Los meto en un objeto auxiliar para pasarlos al metodo "tirarficha" por referencia
					aux.ordenador=ordenador;
					aux.tablero=tablero;
					aux.ficha=ficha;
					aux.totales=totales;
					tirarficha(aux); //Le paso por referencia n_o, forma, tirar, ordenador, tablero, ficha y totales
					//restablezco los valores desde el objeto para dejarlos en las variables locales de "main"
					n_o = aux.n_o;
					tirar = aux.tirar;
					ordenador=aux.ordenador;
					tablero = aux.tablero;
					ficha = aux.ficha;
					totales = aux.totales;
				}				
			}
			//TURNO DEL JUGADOR
			else{
				tirado=false; //marca que no ha tirado todavia ninguna ficha este turno, como en el ordenador
				System.out.println("Turno "+turno+": JUGADOR");
				//Muestra las fichas del jugador por pantalla
				lista(ficha,jugador,n_j); 
				//EN CASO DE QUE SEA EL PRIMER TURNO, EL JUGADOR TIRA AUTOMATICAMENTE
				//AL IGUAL QUE EL ORDENADOR
				if(turno==0&&tablero.equals("")){ /*Si es el primer turno y el tablero esta vacio
													querra decir que empezaba el jugador.*/
					//MAYOR DOBLE
					doble=30;
					for(i=0;i<7;i++){ /* Busca la mayor doble, si tiene las dos caras iguales, comparara con
										la variable "doble" que tiene guardado por defecto (30) y si el identificador
										es menor, es que la ficha doble es de mayor tamaño (pongo 30 puesto que no hay ficha con ese id tan alto)*/
						if(ficha[jugador[i]].cara1 == ficha[jugador[i]].cara2){ 
							if(jugador[i]<doble){
								doble = jugador[i];
								j=i;//Guardo el valor de la ficha del vector jugador que es valida
							}							
						}
					}
					//Una vez encontrada la mayor doble, si se ha encontrado doble!=30, entonces la tira
					if(doble!=30){
						i=j;//Recupero el valor de la posicion del vector ordenador donde esta la ficha que se tira
						tablero = ficha[doble].cara1 + ""+ficha[doble].cara2; //añade al tablero la ficha, los "" es porque sino, no convierte los int a String para concatenarlos
						jugador[i] = jugador[n_j-1]; //Machaca sobre la ficha tirada la ultima ficha que tiene el jugador
						n_j--; //Decrementa el numero de fichas que tienes
						tirado=true; //marca como que ya ha tirado
					}
					//FIN MAYOR DOBLE
					//Si todavia no se ha tirado, el jugador tira la mayor ficha posible
					if(tirado==false){
						j=0; //guarda el identificador de la ficha mayor en esta variable
						k=0;//donde va guardando el valor suma de las caras para su posterior comparacion
						for(i=0;i<7;i++){
							if(ficha[jugador[i]].cara1+ficha[jugador[i]].cara2>k){
								k= ficha[jugador[i]].cara1+ficha[jugador[i]].cara2;
								j=i;//Guarda el identificador de la ficha mayor en la variable J
							}
						}
						tablero = ficha[jugador[j]].cara1 + ""+ficha[jugador[j]].cara2; //añade al tablero la ficha
						jugador[j] = jugador[n_j-1]; //Machaca sobre la ficha tirada la ultima ficha que tiene el jugador
						n_j--; //Decrementa el numero de fichas que tienes
						tirado=true; //marca como que ya ha tirado				
					}
				}
				//FIN DEL CASO PRIMER TURNO
				//SI NO ES EL PRIMER TURNO, te pregunta si quieres robar ficha, si quieres y puedes robas una ficha
				hecho=false;//pone por defecto el valor de parada
				//Busca entre las fichas del jugador a ver si puede tirar aunque sea alguna
				//en ese caso, forma !=0
				devuelve = sepuede(n_j, ficha, jugador,tablero);
				forma = devuelve[0];
				pos1 = devuelve[2]; //Se recogen las posiciones posibles desde "devuelve"
				pos2 = devuelve[3];
				if(tirado==false&&forma==0&&totales<28&&n_j<7){ //Si no se ha tirado,no es posible tirar ninguna ficha y se puede robar 
					do{
						//ROBA UNA FICHA
						/* Genera fichas aleatorias hasta que de con una sin utilizar,
						 * en cuanto lo haga, la reparte y pone como utilizada y cuenta que el jugador
						 * tiene una ficha mas*/
						do{
							hecho = false; //marca que tiene que repartir
							id = random.nextInt(28); // Genera un numero aleatorio entre las fichas
							if(ficha[id].usado == false){
								jugador[n_j] = id;
								ficha[id].usado=true;
								hecho = true;//marca que ya ha repartido
							}
						}
						while (hecho==false);//se repite mientras no se haya repartido
						//Reflejo que he robado una ficha
						n_j++;
						totales++;
						System.out.println("No podias tirar ninguna ficha, has robado. (Pulsa ENTER para continuar)");
						buffer.readLine();
						//LO DEL ENTER HACE MAS FACIL SEGUIR EL JUEGO
						lista(ficha,jugador,n_j);//Enseño las fichas actuales
						//Compruebo si la ficha que he sacado me sirve o no.
						//Busca entre las fichas del jugador a ver si puede tirar aunque sea alguna
						//en ese caso, forma !=0
						devuelve = sepuede(n_j, ficha, jugador,tablero);
						forma = devuelve[0];
						pos1 = devuelve[2]; //Se recogen las posiciones posibles desde "devuelve"
						pos2 = devuelve[3];
					}
					while(forma==0&&n_j<7&&totales<28); //Sigue mientras no tenga una ficha posible para tirar y no llegue al maximo de fichas
				}
				//EL JUGADOR ELIJE LA FICHA QUE TIRA, PERO SOLO SIGUE SI ES POSIBLE TIRA ALGUNA Y ESA ES VALIDA
				if(tirado==false&&n_j>0&&forma!=0){
					hecho = false;//Se ponen a su valor por defecto
					pasar = false;
					do{
						System.out.print("Identificador de la ficha a tirar (introduce (99) para PASAR: ");
						entrada = buffer.readLine();
						if(entrada.equals("")==false){
							tirar = Integer.parseInt(entrada); //Lee por teclado la ficha a tirar (el identificador)
						}
						else
							tirar=28;
						//Si se puede tirar de alguna forma (y no se ha pasado) se sigue
						if(tirar>27&&tirar!=99){ //Quita los errores por numeros invalidos
							//No hace nada, solo quita errores
						}
						else if(tirar!=99&&(ficha[tirar].cara1==pos1||ficha[tirar].cara1==pos2||ficha[tirar].cara2==pos1||ficha[tirar].cara2==pos2)){
							hecho = true;
						}
						else if(tirar==99){
							hecho=true;
							pasar=true;
						}
					}
					while (hecho!=true);
					if(pasar==false){
						System.out.println("Vas a tirar la ficha ");
						ficha[tirar].Mostrar();
						System.out.println();
					}
					hecho =false;//Pide el lado donde se introducira la ficha
					if(pasar==false)  //Solo se hace si no se paso anteriormente el turno
					do{
						System.out.print("¿A que lado la quieres tirar? (I)zquierda/(D)erecha: ");
						entrada = buffer.readLine().toUpperCase();
						if(entrada.equals(""))				//Con este IF, si no se introdujo lado, no da error
							car = '0';
						else
							car = entrada.charAt(0);
						/* Comparo los distintos casos de que coincida la ficha con una posicion valida
						 * y determino si se puede colocar la ficha y si hay que rotarla
						 * hasta que no se pueda colocar en algun lado, no se marca como hecho y
						 * no sale del bucle
						 */
						if(car=='I'&&pos1==ficha[tirar].cara2){
							hecho=true;
							rotar=false;
						}
						else if(car=='I'&&pos1==ficha[tirar].cara1){
							hecho=true;
							rotar=true;
						}
						else if(car=='D'&&pos2==ficha[tirar].cara1){
							hecho=true;
							rotar=false;
						}
						else if(car=='D'&&pos2==ficha[tirar].cara2){
							hecho=true;
							rotar=true;
						}
						else
							hecho=false;
					}
					while(hecho==false);
					//Una vez elegido donde colocarla, la ficha se coloca dependiendo que hayas puesto
					//COLOCAR LA FICHA(solo se hace si no se paso el turno)
					if(pasar==false){
						if(car=='I'&&rotar==false){
							cara1 = ficha[tirar].cara1 + "";//Pongo en cada cara su valor en forma de STring
							cara2 = ficha[tirar].cara2 + "";//Lo hago con strings auxiliares, porque si no los usaba
							cara2 = ficha[tirar].cara2 + "";//me sumaba los valores de las caras antes de concatenar
							tablero = cara1 + cara2 + tablero;
						}
						else if (car=='I'&&rotar==true){
							cara1 = ficha[tirar].cara1 + ""; //Pongo en cada cara su valor en forma de STring
							cara2 = ficha[tirar].cara2 + "";
							tablero = cara2 + cara1 + tablero;
						}
						else if (car=='D'&&rotar==false){
							cara1 = ficha[tirar].cara1 + ""; //Pongo en cada cara su valor en forma de STring
							cara2 = ficha[tirar].cara2 + "";
							tablero = tablero + cara1 + cara2;
						}
						else if (car=='D'&&rotar==true){
							cara1 = ficha[tirar].cara1 + ""; //Pongo en cada cara su valor en forma de STring
							cara2 = ficha[tirar].cara2 + "";
							tablero = tablero + cara2 + cara1;
						}
						//Sabemos la identidad de la ficha, pero no sabemos en que posicion
						//Del vector jugador se encuentra, asi es que la buscamos
						for(i=0;i<n_j;i++)
							if(tirar==jugador[i])
								id=i;
						//una vez encontrado, podemos usarlo para borrar la ficha que se ha tirado
						jugador[id] = jugador[n_j-1]; //Machaca sobre la ficha tirada la ultima ficha que tiene el jugador
						n_j--; //Decrementa el numero de fichas que tienes
					}
					//FIN COLOCAR FICHA
					if(pasar)
						System.out.println("HAS PASADO TURNO");		
				}
				else if (forma==0){
					System.out.println("HAS PASADO TURNO AUTOMATICAMENTE (No tienes fichas para tirar y no puedes robar mas.)\nPulsa ENTER para continuar"); //Si aun despues de robar sigues sin tener fichas
					buffer.readLine();																														//para tirar, pasa turno automaticamente.
				}
			}
			turno++;//avanza el turno
			/* CONDICION DE VICTORIA
			 * Gana el que primero se quede sin fichas en la mano.*/
			if(n_o==0){
				System.out.println("HA GANADO EL ORDENADOR");
				termina=true;
			}
			if(n_j==0){
				System.out.println("HA GANADO EL JUGADOR");
				termina=true;
			}
			if(n_j>0&&n_o>0&&totales==28){
				System.out.println("EMPATE");
				termina=true;
			}
		}
		while(termina==false); //Repite turnos alternativos mientras que no se hayan repartido todas las fichas
		
		//Para comprobar quien ha ganado de verdad, muestra las fichas de ambos jugadores
		System.out.println("\tSITUACION FINAL:\n\n\tORDENADOR");
		lista(ficha,ordenador,n_o);
		System.out.println("\tJUGADOR");
		lista(ficha,jugador,n_j);
		
	}
}
/* RELACION DE IDENTIFICADORES DE CADA FICHA GENERADA
 0.- |6|·|6| 	 1.- |6|·|5| 	 2.- |6|·|4| 	 3.- |6|·|3| 	 4.- |6|·|2| 	 5.- |6|·|1| 	 6.- |6|·|0|
 7.- |5|·|5| 	 8.- |5|·|4| 	 9.- |5|·|3| 	10.- |5|·|2| 	11.- |5|·|1| 	12.- |5|·|0| 	13.- |4|·|4|
14.- |4|·|3|	15.- |4|·|2|	16.- |4|·|1|	17.- |4|·|0| 	18.- |3|·|3|	19.- |3|·|2|	20.- |3|·|1|
21.- |3|·|0|	22.- |2|·|2|	23.- |2|·|1|	24.- |2|·|0|	25.- |1|·|1|	26.- |1|·|0|	27.- |0|·|0| */